helpers.js ➔ bytesToBase - Code Metrics - Inspection of "organized tests" - rochars/byte-data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0d02ce...fc63cf )

by Rafael S.

created 2017-12-04 16:43 UTC

helpers.js ➔ bytesToBase A

↳ Parent: src/helpers.js

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
nc	3
nop	3
dl	0
loc	11
rs	9.4285

/*
 * helpers: functions to work with bytes and byte arrays.
 * Copyright (c) 2017 Rafael da Silva Rocha.
 * https://github.com/rochars/byte-data
 */

const endianness = require("endianness");
const bitDepths = require("../src/bit-depth.js");

/**
 * Padding for binary strings.
 * @param {!Array<string>} bytes The bytes as binary strings.
 * @param {number} base The base.
 * @param {number} index The byte to pad.
 */
function padding(bytes, base, index) {
    bytes[index] = bytePadding(bytes[index], base);
}

/**
 * Padding with 0s for byte strings.
 * @param {string} theByte The byte as a binary or hex string.
 * @param {number} base The base.
 * @returns {string} The padded byte.
 */
function bytePadding(theByte, base) {
    let offset = theByte.length + 1;
    if (base == 2) {
        offset = 8;
    } else if (base == 16) {
        offset = 2;
    }
    return lPadZeros(theByte, offset);
}

/**
 * Fix the size of nibbles.
 * @param {!Array<string>} nibbles The nibble as a binary or hex string.
 * @param {number} base The base.
 * @param {number} index The nibble offset.
 */
function paddingNibble(nibbles, base, index) {
    if (base == 2 && nibbles[index].length < 4) {
        nibbles[index] = 
            new Array((5 - nibbles[index].length)).join("0")  + nibbles[index];
    }
}   

/**
 * Fix the size of crumbs.
 * @param {!Array<string>} crumbs The nibble as a binary or hex string.
 * @param {number} base The base.
 * @param {number} index The nibble offset.
 */
function paddingCrumb(crumbs, base, index) {
    if ((base == 2 || base == 16) && crumbs[index].length < 2) {
        crumbs[index] = '0' + crumbs[index];
    }
}   

/**
 * Pad a string with zeros to the left.
 * TODO: This should support both arrays and strings.
 * @param {string} value The string (representing a binary or hex value).
 * @param {number} numZeros the max number of zeros.
 *      For 1 binary byte string it should be 8.
 */
function lPadZeros(value, numZeros) {
    while (value.length < numZeros) {
        value = '0' + value;
    }
    return value;
}

/**
 * Swap the endianness to big endian.
 * @param {!Array<number>} bytes The values.
 * @param {boolean} isBigEndian True if the bytes should be big endian.
 * @param {number} bitDepth The bitDepth of the data.
 */
function makeBigEndian(bytes, isBigEndian, bitDepth) {
    if (isBigEndian) {
        endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);
    }
}

/**
 * Turn bytes to base 2, 10 or 16.
 * @param {!Array<string>|!Array<number>} bytes The bytes.
 * @param {number} base The base.
 * @param {Function} padFunction The function to use for padding.
 */
function bytesToBase(bytes, base, padFunction=padding) {
    if (base != 10) {
        let i = 0;
        let len = bytes.length;
        while (i < len) {
            bytes[i] = bytes[i].toString(base);
            padFunction(bytes, base, i);
            i++;
        }
    }
}

/**
 * Turn the output to the correct base.
 * @param {!Array<number>} bytes The bytes.
 * @param {number} bitDepth The bit depth of the data.
 * @param {number} base The desired base for the output data.
 */
function outputToBase(bytes, bitDepth, base) {
    if (bitDepth == 4) {
        bytesToBase(bytes, base, paddingNibble);
    } else if (bitDepth == 2) {
        bytesToBase(bytes, base, paddingCrumb);
    } else if(bitDepth == 1) {
        bytesToBase(bytes, base, function(){});
    }else {
        bytesToBase(bytes, base);
    }
}

/**
 * Turn a unsigned number to a signed number.
 * @param {number} num The number.
 * @param {number} maxValue The max range for the number bit depth.
 */
function signed(num, maxValue) {
    if (num > parseInt(maxValue / 2, 10) - 1) {
        num -= maxValue;
    }
    return num;
}

/**
 * Fix the endianness of float16 bytes (r/w is always big-endian).
 * @param {!Array<number>|Uint8Array} bytes The bytes.
 * @param {Object} options The type.
 */
function fixFloat16Endianness(bytes, options) {
    if (options.float && options.bits == 16) {
        endianness(bytes, 2);
    }
}

/**
 * Get the full type spec for the reading/writing.
 * @param {Object} atype One of the available types.
 * @param {number} base The base of the input.
 * @param {boolean} single True if its a single value, false for array.
 * @return {Object}
 */
function getType(atype, base, single) {
    let theType = Object.assign({}, atype);
    theType.base = base;
    theType.single = single;
    if (theType.bits == 64) {
        theType.float = true;
    }
    if (theType.float) {
        theType.signed = true;
    }
    return theType;
}

/**
 * Make a single value an array in case it is not.
 * If the value is a string it stays a string.
 * @param {!Array<number>|number|string} values The value or values.
 * @return {!Array<number>|string}
 */
function turnToArray(values) {
    if (!Array.isArray(values) && typeof values != "string") {
        values = [values];
    }
    return values;
}


module.exports.makeBigEndian = makeBigEndian;
module.exports.bytesToBase = bytesToBase;
module.exports.outputToBase = outputToBase;
module.exports.signed = signed;
module.exports.padding = padding;
module.exports.paddingNibble = paddingNibble;
module.exports.paddingCrumb = paddingCrumb;
module.exports.bytePadding = bytePadding;
module.exports.lPadZeros = lPadZeros;
module.exports.fixFloat16Endianness = fixFloat16Endianness;
module.exports.getType = getType;
module.exports.turnToArray = turnToArray;


1			/*
2			* helpers: functions to work with bytes and byte arrays.
3			* Copyright (c) 2017 Rafael da Silva Rocha.
4			* https://github.com/rochars/byte-data
5			*/
6
7			const endianness = require("endianness");
8			const bitDepths = require("../src/bit-depth.js");
9
10			/**
11			* Padding for binary strings.
12			* @param {!Array<string>} bytes The bytes as binary strings.
13			* @param {number} base The base.
14			* @param {number} index The byte to pad.
15			*/
16			function padding(bytes, base, index) {
17			bytes[index] = bytePadding(bytes[index], base);
18			}
19
20			/**
21			* Padding with 0s for byte strings.
22			* @param {string} theByte The byte as a binary or hex string.
23			* @param {number} base The base.
24			* @returns {string} The padded byte.
25			*/
26			function bytePadding(theByte, base) {
27			let offset = theByte.length + 1;
28			if (base == 2) {
29			offset = 8;
30			} else if (base == 16) {
31			offset = 2;
32			}
33			return lPadZeros(theByte, offset);
34			}
35
36			/**
37			* Fix the size of nibbles.
38			* @param {!Array<string>} nibbles The nibble as a binary or hex string.
39			* @param {number} base The base.
40			* @param {number} index The nibble offset.
41			*/
42			function paddingNibble(nibbles, base, index) {
43			if (base == 2 && nibbles[index].length < 4) {
44			nibbles[index] =
45			new Array((5 - nibbles[index].length)).join("0") + nibbles[index];
46			}
47			}
48
49			/**
50			* Fix the size of crumbs.
51			* @param {!Array<string>} crumbs The nibble as a binary or hex string.
52			* @param {number} base The base.
53			* @param {number} index The nibble offset.
54			*/
55			function paddingCrumb(crumbs, base, index) {
56			if ((base == 2 \|\| base == 16) && crumbs[index].length < 2) {
57			crumbs[index] = '0' + crumbs[index];
58			}
59			}
60
61			/**
62			* Pad a string with zeros to the left.
63			* TODO: This should support both arrays and strings.
64			* @param {string} value The string (representing a binary or hex value).
65			* @param {number} numZeros the max number of zeros.
66			* For 1 binary byte string it should be 8.
67			*/
68			function lPadZeros(value, numZeros) {
69			while (value.length < numZeros) {
70			value = '0' + value;
71			}
72			return value;
73			}
74
75			/**
76			* Swap the endianness to big endian.
77			* @param {!Array<number>} bytes The values.
78			* @param {boolean} isBigEndian True if the bytes should be big endian.
79			* @param {number} bitDepth The bitDepth of the data.
80			*/
81			function makeBigEndian(bytes, isBigEndian, bitDepth) {
82			if (isBigEndian) {
83			endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);
84			}
85			}
86
87			/**
88			* Turn bytes to base 2, 10 or 16.
89			* @param {!Array<string>\|!Array<number>} bytes The bytes.
90			* @param {number} base The base.
91			* @param {Function} padFunction The function to use for padding.
92			*/
93			function bytesToBase(bytes, base, padFunction=padding) {
94			if (base != 10) {
95			let i = 0;
96			let len = bytes.length;
97			while (i < len) {
98			bytes[i] = bytes[i].toString(base);
99			padFunction(bytes, base, i);
100			i++;
101			}
102			}
103			}
104
105			/**
106			* Turn the output to the correct base.
107			* @param {!Array<number>} bytes The bytes.
108			* @param {number} bitDepth The bit depth of the data.
109			* @param {number} base The desired base for the output data.
110			*/
111			function outputToBase(bytes, bitDepth, base) {
112			if (bitDepth == 4) {
113			bytesToBase(bytes, base, paddingNibble);
114			} else if (bitDepth == 2) {
115			bytesToBase(bytes, base, paddingCrumb);
116			} else if(bitDepth == 1) {
117			bytesToBase(bytes, base, function(){});
118			}else {
119			bytesToBase(bytes, base);
120			}
121			}
122
123			/**
124			* Turn a unsigned number to a signed number.
125			* @param {number} num The number.
126			* @param {number} maxValue The max range for the number bit depth.
127			*/
128			function signed(num, maxValue) {
129			if (num > parseInt(maxValue / 2, 10) - 1) {
130			num -= maxValue;
131			}
132			return num;
133			}
134
135			/**
136			* Fix the endianness of float16 bytes (r/w is always big-endian).
137			* @param {!Array<number>\|Uint8Array} bytes The bytes.
138			* @param {Object} options The type.
139			*/
140			function fixFloat16Endianness(bytes, options) {
141			if (options.float && options.bits == 16) {
142			endianness(bytes, 2);
143			}
144			}
145
146			/**
147			* Get the full type spec for the reading/writing.
148			* @param {Object} atype One of the available types.
149			* @param {number} base The base of the input.
150			* @param {boolean} single True if its a single value, false for array.
151			* @return {Object}
152			*/
153			function getType(atype, base, single) {
154			let theType = Object.assign({}, atype);
155			theType.base = base;
156			theType.single = single;
157			if (theType.bits == 64) {
158			theType.float = true;
159			}
160			if (theType.float) {
161			theType.signed = true;
162			}
163			return theType;
164			}
165
166			/**
167			* Make a single value an array in case it is not.
168			* If the value is a string it stays a string.
169			* @param {!Array<number>\|number\|string} values The value or values.
170			* @return {!Array<number>\|string}
171			*/
172			function turnToArray(values) {
173			if (!Array.isArray(values) && typeof values != "string") {
174			values = [values];
175			}
176			return values;
177			}
178
179
180			module.exports.makeBigEndian = makeBigEndian;
181			module.exports.bytesToBase = bytesToBase;
182			module.exports.outputToBase = outputToBase;
183			module.exports.signed = signed;
184			module.exports.padding = padding;
185			module.exports.paddingNibble = paddingNibble;
186			module.exports.paddingCrumb = paddingCrumb;
187			module.exports.bytePadding = bytePadding;
188			module.exports.lPadZeros = lPadZeros;
189			module.exports.fixFloat16Endianness = fixFloat16Endianness;
190			module.exports.getType = getType;
191			module.exports.turnToArray = turnToArray;
192

rochars / byte-data

Push — master ( 0d02ce...fc63cf )

helpers.js ➔ bytesToBase A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like